/**
 * 智能对话助手前端逻辑
 * 处理用户交互、WebSocket通信及界面更新
 */
$(document).ready(function() {
    // 全局变量
    const sessionId = document.querySelector('meta[name="session-id"]')?.content || '';
    let stompClient = null;
    let currentDeleteSessionId = null;

    console.log('jQuery version:', $.fn.jquery);

    // ===== 初始化 =====
    // 连接WebSocket
    connect();
    // 页面加载后滚动到底部
    scrollToBottom();
    initializeEventHandlers();




    /**
     * 初始化所有事件处理器
     */
    function initializeEventHandlers() {
        // 解除可能冲突的事件绑定
        clearEventBindings();

        // 输入区域事件
        initInputEvents();

        // 功能按钮事件
        initActionEvents();

        // 模态框相关事件
        initModalEvents();

        // 文件上传事件 - 只在这里调用一次
        initFileUploadEvents();
    }


    // 修改输入事件处理，更新发送按钮状态
    $('#messageInput').on('input', function() {
        this.style.height = 'auto';
        this.style.height = (this.scrollHeight) + 'px';

        // 更新发送按钮状态
        updateSendButton();
    });
    /**
     * 清除可能冲突的事件绑定
     */
    function clearEventBindings() {
        $('.modal-backdrop').off('click');
        $('.modal-close, #cancelRename, #cancelDelete, #cancelClear, #closeHelp, #closeRenameModal, #closeDeleteModal, #closeClearModal, #closeHelpModal').off('click');
        $('#confirmDelete, #confirmRename, #confirmClear').off('click');
    }

    /**
     * 初始化输入区域事件处理
     */
    function initInputEvents() {
        // 自动调整文本区域高度
        const messageInput = document.getElementById('messageInput');
        messageInput.addEventListener('input', function() {
            this.style.height = 'auto';
            this.style.height = (this.scrollHeight) + 'px';
            // 启用/禁用发送按钮
            $('#sendButton').prop('disabled', this.value.trim() === '' && pendingFiles.length === 0);
            updateSendButton();
        });

        // 发送按钮点击事件 - 修改为检查是否有待发送文件
        $('#sendButton').on('click', function() {
            if (pendingFiles.length > 0) {
                sendMessageWithFiles();
            } else {
                sendMessage();
            }
        });

        // 输入框键盘事件
        $('#messageInput').on('keydown', function(e) {
            if (e.which === 13 && !e.shiftKey) { // Enter键但不按Shift
                e.preventDefault();
                if (this.value.trim() !== '') {
                    sendMessage();
                }
                return false;
            } else if (e.which === 27) { // Esc键
                $(this).val('');
                $(this).css('height', 'auto');
                $('#sendButton').prop('disabled', true);
            }
        });

        // 清空输入按钮
        $('#clearInputBtn').on('click', function() {
            $('#messageInput').val('');
            $('#messageInput').css('height', 'auto');
            $('#sendButton').prop('disabled', true);
            $('#messageInput').focus();
        });
    }

    /**
     * 初始化功能按钮事件
     */
    function initActionEvents() {
        // 文件上传按钮事件
        $('#fileUploadButton').on('click', function() {
            $('#fileInput').click();
        });


        // 帮助按钮
        $('#helpBtn').on('click', function() {
            showModal('helpModal');
        });

        // 导出聊天记录
        $('#exportChat').on('click', exportChatHistory);

        // 清空聊天确认
        $('#clearChat').on('click', function() {
            showModal('clearModal');
        });

        // 重命名对话
        $('#renameChat').on('click', function() {
            const currentName = $('.chat-header h4 span').text();
            $('#chatName').val(currentName);
            showModal('renameModal');
        });

        // 删除会话
        $(document).on('click', '.delete-btn', function(e) {
            e.preventDefault();
            e.stopPropagation();
            currentDeleteSessionId = $(this).data('id');
            console.log('Delete button clicked, ID:', currentDeleteSessionId);
            showModal('deleteModal');
        });

        // 移动端侧边栏切换
        $('#sidebarToggle').on('click', function() {
            $('#sidebar').toggleClass('expanded');
        });

        // 点击聊天区域关闭展开的侧边栏
        $('.chat-area').on('click', function() {
            if ($('#sidebar').hasClass('expanded')) {
                $('#sidebar').removeClass('expanded');
            }
        });
    }

    /**
     * 初始化模态框相关事件
     */
    function initModalEvents() {
        // 模态框背景点击事件
        $('.modal-backdrop').on('click', function(e) {
            // 只有当点击的是模态框背景时才关闭
            if (e.target === this) {
                hideModals();
            }
        });

        // 模态框关闭按钮
        $('.modal-close').on('click', function(e) {
            e.stopPropagation();
            hideModals();
        });

        // 删除对话模态框
        $('#confirmDelete').on('click', function(e) {
            e.stopPropagation();
            console.log('确认删除按钮被点击，ID:', currentDeleteSessionId);
            if (currentDeleteSessionId) {
                deleteChat(currentDeleteSessionId);
                hideModals();
            }
        });

        $('#cancelDelete').on('click', function(e) {
            e.stopPropagation();
            hideModals();
        });

        // 重命名对话模态框
        $('#confirmRename').on('click', function(e) {
            e.stopPropagation();
            const newName = $('#chatName').val().trim();
            if (newName) {
                renameChat(newName);
                hideModals();
            } else {
                showToast('warning', '提示', '对话名称不能为空');
            }
        });

        $('#cancelRename').on('click', function(e) {
            e.stopPropagation();
            hideModals();
        });

        // 清空对话模态框
        $('#confirmClear').on('click', function(e) {
            e.stopPropagation();
            clearChat();
            hideModals();
        });

        $('#cancelClear').on('click', function(e) {
            e.stopPropagation();
            hideModals();
        });

        // 帮助模态框
        $('#closeHelp').on('click', function(e) {
            e.stopPropagation();
            hideModals();
        });
    }

    // ===== WebSocket 相关函数 =====

    /**
     * 建立WebSocket连接
     * 先尝试连接到 /websocket-chat，如果失败则尝试 /websocket
     */
    function connect() {
        try {
            // 尝试连接到 /websocket-chat (前端当前使用的端点)
            const socket = new SockJS('/websocket-chat');
            stompClient = Stomp.over(socket);

            // 设置调试级别: 正式环境可以关闭调试输出
            // stompClient.debug = null;

            // 为调试目的保留debug
            stompClient.debug = function(str) {
                console.log('STOMP: ' + str);
            };

            // 将stompClient暴露到全局作用域，以便stream-chat.js可以访问
            window.stompClient = stompClient;

            stompClient.connect({}, function(frame) {
                console.log('WebSocket连接成功: ' + frame);

                // 订阅常规聊天主题
                stompClient.subscribe('/topic/chat/' + sessionId, function(messageOutput) {
                    // 隐藏输入指示器
                    $('#typingIndicator').hide();
                    // 隐藏思考过程
                    hideThinkingProcess();
                    // 显示消息
                    showMessage(JSON.parse(messageOutput.body));
                });

                // 订阅会话状态更新主题
                stompClient.subscribe('/topic/session/' + sessionId, function(sessionUpdate) {
                    try {
                        const updateData = JSON.parse(sessionUpdate.body);

                        // 处理重命名操作
                        if (updateData.action === "rename" && updateData.sessionId === sessionId) {
                            // 更新页面上的会话名称
                            $('.chat-header h4 span').text(updateData.newName);

                            // 同时更新侧边栏中当前会话的名称
                            $('a.session-item.active .session-name').text(updateData.newName);

                            console.log('会话已自动重命名为:', updateData.newName);
                        }
                    } catch (e) {
                        console.error('处理会话更新消息出错:', e);
                    }
                });

                // 订阅流式聊天主题
                stompClient.subscribe('/topic/stream/' + sessionId, function(tokenOutput) {
                    if(window.handleTokenUpdate) {
                        window.handleTokenUpdate(tokenOutput.body);
                    }
                });

                // 订阅流式完成主题
                stompClient.subscribe('/topic/complete/' + sessionId, function(completeOutput) {
                    if(window.handleGenerationComplete) {
                        window.handleGenerationComplete(completeOutput.body);
                    }
                });

            }, function(error) {
                console.log('WebSocket连接失败: ' + error);
                // 尝试连接到备用端点 /websocket
                connectFallback();
            });
        } catch (error) {
            console.error('WebSocket连接出错:', error);
            // 尝试连接到备用端点
            connectFallback();
        }
    }

    /**
     * 备用WebSocket连接方法
     * 当主要端点连接失败时使用
     */
    function connectFallback() {
        try {
            console.log('尝试备用WebSocket连接...');
            const socket = new SockJS('/websocket');
            stompClient = Stomp.over(socket);

            // 设置调试级别
            // stompClient.debug = null;

            // 为调试目的保留debug
            stompClient.debug = function(str) {
                console.log('STOMP Fallback: ' + str);
            };

            // 将stompClient暴露到全局作用域
            window.stompClient = stompClient;

            stompClient.connect({}, function(frame) {
                console.log('备用WebSocket连接成功: ' + frame);

                // 订阅相同的主题
                stompClient.subscribe('/topic/chat/' + sessionId, function(messageOutput) {
                    $('#typingIndicator').hide();
                    hideThinkingProcess();
                    showMessage(JSON.parse(messageOutput.body));
                });

                stompClient.subscribe('/topic/stream/' + sessionId, function(tokenOutput) {
                    if(window.handleTokenUpdate) {
                        window.handleTokenUpdate(tokenOutput.body);
                    }
                });

                stompClient.subscribe('/topic/complete/' + sessionId, function(completeOutput) {
                    if(window.handleGenerationComplete) {
                        window.handleGenerationComplete(completeOutput.body);
                    }
                });

            }, function(error) {
                console.log('备用WebSocket连接也失败: ' + error);
                setTimeout(connect, 5000); // 5秒后尝试重新连接
                showToast('error', '连接错误', '与服务器的连接已断开，正在尝试重新连接...');
            });
        } catch (error) {
            console.error('备用WebSocket连接出错:', error);
            showToast('error', '连接错误', '无法建立WebSocket连接');
            setTimeout(connect, 5000); // 5秒后尝试重新连接
        }
    }

    /**
     * 保持WebSocket连接活动
     */
    setInterval(function() {
        if (stompClient && stompClient.connected) {
            stompClient.send("/app/chat.keepAlive", {}, JSON.stringify({}));
        }
    }, 30000);

    // ===== 消息处理函数 =====

    /**
     * 发送消息到服务器
     */
    function sendMessageLegacy() {
        const message = document.getElementById('messageInput').value.trim();

        if (message !== '') {
            // 立即显示用户消息
            showMessage({
                role: 'user',
                content: message
            });

            // 清空输入并重置高度
            document.getElementById('messageInput').value = '';
            document.getElementById('messageInput').style.height = 'auto';
            $('#sendButton').prop('disabled', true);

            // 显示思考过程（新增）
            showThinkingProcess();

            // 显示输入指示器
            $('#typingIndicator').show();
            scrollToBottom();

            // 调用API
            $.ajax({
                url: '/api/chat/' + sessionId + '/send',
                type: 'POST',
                data: { message: message },
                success: function(response) {
                    console.log('消息发送成功');
                    // 隐藏思考过程
                    hideThinkingProcess();
                },
                error: function(error) {
                    console.error('发送消息错误', error);
                    $('#typingIndicator').hide();
                    // 隐藏思考过程
                    hideThinkingProcess();
                    showMessage({
                        role: 'assistant',
                        content: '发送消息时出错，请稍后再试。'
                    });
                    showToast('error', '发送失败', '无法发送消息，请检查网络连接。');
                }
            });
        }
    }

    // 添加新的sendMessage函数，默认使用流式API
    function sendMessage() {
        const message = document.getElementById('messageInput').value.trim();

        if (message !== '') {
            if (window.sendStreamingMessage) {
                // 使用流式API
                window.sendStreamingMessage(message);
            } else {
                // 回退到传统API
                sendMessageLegacy();
            }
        }
    }

    // 2. 添加思考过程显示和隐藏函数

    /**
     * 显示AI思考过程
     * 在用户等待回复时显示思考步骤
     */
    function showThinkingProcess() {
        // 创建思考过程容器
        const thinkingContainer = $('<div id="thinking-process" class="message-container"></div>');

        // 创建AI头像
        const avatarElement = $('<div class="message-avatar"></div>')
            .append($('<i class="fas fa-robot"></i>'));

        thinkingContainer.append(avatarElement);

        // 创建思考内容
        const messageContent = $('<div class="message-content"></div>');
        const messageBubble = $('<div class="message-bubble assistant thinking-bubble"></div>')
            .append($('<div id="thinking-content"></div>').html('<p>正在思考中...</p>'));

        messageContent.append(messageBubble);
        thinkingContainer.append(messageContent);

        // 添加到消息列表
        $('#messageList').append(thinkingContainer);
        scrollToBottom();

        // 启动思考过程动画
        startThinkingAnimation();
    }

    /**
     * 隐藏思考过程
     */
    function hideThinkingProcess() {
        // 停止动画
        clearInterval(thinkingAnimationInterval);
        // 移除思考过程元素
        $('#thinking-process').remove();
    }

// 思考动画相关变量
    let thinkingAnimationInterval;
    let thinkingStep = 0;
    const thinkingSteps = [
        "正在分析问题...",
        "查找相关信息...",
        "整理思路与逻辑...",
        "参考历史对话...",
        "组织回复内容...",
        "优化表达方式...",
        "最终检查..."
    ];

    /**
     * 启动思考过程动画
     */
    function startThinkingAnimation() {
        thinkingStep = 0;
        updateThinkingContent();

        // 每2秒更新一次思考步骤
        thinkingAnimationInterval = setInterval(function() {
            thinkingStep++;
            if (thinkingStep >= thinkingSteps.length) {
                thinkingStep = 0; // 循环显示
            }
            updateThinkingContent();
        }, 2000);
    }

    /**
     * 更新思考内容
     */
    function updateThinkingContent() {
        const thinkingContent = $('#thinking-content');
        if (thinkingContent.length) {
            let content = `<p>${thinkingSteps[thinkingStep]}</p>`;

            // 添加进度点
            content += '<div class="thinking-dots">';
            for (let i = 0; i < thinkingSteps.length; i++) {
                if (i === thinkingStep) {
                    content += '<span class="thinking-dot active"></span>';
                } else {
                    content += '<span class="thinking-dot"></span>';
                }
            }
            content += '</div>';

            thinkingContent.html(content);
            scrollToBottom();
        }
    }

    /**
     * 在界面上显示消息
     * @param {Object} message 消息对象，包含role和content属性
     */
    function showMessage(message) {
        // 如果是第一条消息，移除欢迎界面
        if ($('#messageList .welcome-screen').length > 0) {
            $('#messageList').empty();

            // 添加日期分隔符
            const dateDivider = $('<div class="message-date-divider"><span>' +
                formatDate(new Date(), 'yyyy年MM月dd日') + '</span></div>');
            $('#messageList').append(dateDivider);
        }

        const messageContainer = $('<div class="message-container"></div>');

        // 创建头像
        const avatarClass = message.role === 'user' ? 'user' :
            message.role === 'system' ? 'system' : 'assistant';
        const avatarIcon = message.role === 'user' ? 'user' :
            message.role === 'system' ? 'cog' : 'robot';

        const avatarElement = $('<div class="message-avatar ' + avatarClass + '"></div>')
            .append($('<i class="fas fa-' + avatarIcon + '"></i>'));

        messageContainer.append(avatarElement);

        // 创建消息内容
        const messageContent = $('<div class="message-content"></div>');

        // 直接使用内容，确保应用Markdown格式化
        const messageBubble = $('<div class="message-bubble ' + message.role + '"></div>')
            .append($('<div></div>').html(formatMessage(message.content)));

        messageContent.append(messageBubble);

        // 添加时间戳
        const timestamp = new Date();
        const timeString = formatDate(timestamp, 'HH:mm:ss');
        messageContent.append($('<div class="message-meta"></div>').text(timeString));

        messageContainer.append(messageContent);
        $('#messageList').append(messageContainer);
        scrollToBottom();
    }

    /**
     * 滚动消息列表到底部
     */
    function scrollToBottom() {
        const messageList = document.getElementById('messageList');
        messageList.scrollTop = messageList.scrollHeight;
    }

    /**
     * 格式化消息
     */
    function formatMessage(content) {
        // 处理代码块
        let formatted = content.replace(/```(\w*)([\s\S]*?)```/g, function(match, language, code) {
            return '<pre><code class="language-' + language + '">' +
                code.trim() + '</code></pre>';
        });

        // 处理单行代码
        formatted = formatted.replace(/`([^`]+)`/g, '<code>$1</code>');

        // 处理换行
        formatted = formatted.replace(/\n/g, '<br>');

        return formatted;
    }

    // ===== 文件处理函数 =====

    /**
     * 上传文件到服务器
     * @param {File} file 要上传的文件对象
     */
    // 3. 同样需要在文件上传函数中添加思考过程

    /**
     * 上传文件
     * @param {File} file 要上传的文件对象
     */
// 更新文件上传处理函数
    function uploadFile(file) {
        const formData = new FormData();
        formData.append('file', file);

        // 显示上传消息
        showMessage({
            role: 'user',
            content: '上传文件: ' + file.name
        });

        // 显示处理进度
        const progressContainer = $('<div class="processing-progress-container"></div>');
        const progressBar = $(`
        <div class="progress">
            <div class="progress-bar" role="progressbar" style="width: 10%;" 
                 aria-valuenow="10" aria-valuemin="0" aria-valuemax="100">10%</div>
        </div>
        <div class="processing-step">正在上传文件...</div>
    `);
        progressContainer.append(progressBar);
        $('#messageList').append(progressContainer);
        scrollToBottom();

        // 上传文件到服务器
        $.ajax({
            url: '/api/files/upload/' + sessionId,
            type: 'POST',
            data: formData,
            processData: false,
            contentType: false,
            xhr: function() {
                const xhr = new window.XMLHttpRequest();
                xhr.upload.addEventListener('progress', function(e) {
                    if (e.lengthComputable) {
                        const percent = Math.round((e.loaded / e.total) * 100);
                        progressBar.find('.progress-bar').css('width', percent + '%');
                        progressBar.find('.progress-bar').attr('aria-valuenow', percent);
                        progressBar.find('.progress-bar').text(percent + '%');

                        if (percent < 100) {
                            progressBar.siblings('.processing-step').text('正在上传文件...');
                        } else {
                            progressBar.siblings('.processing-step').text('文件已上传，正在处理...');
                        }
                    }
                }, false);
                return xhr;
            },
            success: function(response) {
                console.log('文件上传成功', response);

                // 更新进度条状态
                progressBar.find('.progress-bar').css('width', '100%');
                progressBar.find('.progress-bar').addClass('bg-success');

                if (response.chunks) {
                    progressBar.siblings('.processing-step').text('处理完成！已分割为 ' + response.chunks + ' 个文本块');
                } else {
                    progressBar.siblings('.processing-step').text('文件处理完成！');
                }

                // 3秒后移除进度条
                setTimeout(function() {
                    progressContainer.fadeOut(500, function() {
                        $(this).remove();
                    });
                }, 3000);

                $('#fileInfo').text('');
                $('#fileInput').val('');
                showToast('success', '上传成功', '文件已上传，可以开始提问。');
                // 在这里添加可点击的文件操作建议
                showFileActionSuggestions(file.name);
            },
            error: function(error) {
                console.error('文件上传失败', error);

                // 更新进度条状态
                progressBar.find('.progress-bar').css('width', '100%');
                progressBar.find('.progress-bar').addClass('bg-danger');
                progressBar.siblings('.processing-step').text('文件处理失败: ' +
                    (error.responseJSON?.error || '未知错误'));

                // 5秒后移除进度条
                setTimeout(function() {
                    progressContainer.fadeOut(500, function() {
                        $(this).remove();
                    });
                }, 5000);

                showMessage({
                    role: 'assistant',
                    content: '文件上传失败，请稍后再试。'
                });
                $('#fileInfo').text('');
                $('#fileInput').val('');
                showToast('error', '上传失败', '文件上传失败，请稍后重试。');
            }
        });
    }

    // 添加这个新函数到index.js文件中
    function showFileActionSuggestions(fileName) {
        const suggestionsHtml = `
        <div class="file-uploaded-message">
            <p>已上传文件: <strong>${fileName}</strong></p>
            <p>您可以选择以下操作:</p>
            <div class="action-suggestions">
                <button class="action-suggestion-btn" data-action="分析整个文件内容">
                    <i class="fas fa-search"></i> 分析整个文件内容
                </button>
                <button class="action-suggestion-btn" data-action="提取文件中的关键信息">
                    <i class="fas fa-key"></i> 提取文件中的关键信息
                </button>
                <button class="action-suggestion-btn" data-action="总结文件内容">
                    <i class="fas fa-file-alt"></i> 总结文件内容
                </button>
                <button class="action-suggestion-btn" data-action="查找文件中的主要问题">
                    <i class="fas fa-question-circle"></i> 查找文件中的主要问题
                </button>
            </div>
        </div>
    `;

        // 显示建议消息
        showMessage({
            role: 'assistant',
            content: suggestionsHtml
        });

        // 为建议按钮添加点击事件
        setTimeout(function() {
            $('.action-suggestion-btn').on('click', function() {
                const action = $(this).data('action');
                // 将选择的操作填入输入框
                $('#messageInput').val(action);
                // 触发输入变化事件以更新高度
                $('#messageInput').trigger('input');
                // 启用发送按钮
                $('#sendButton').prop('disabled', false);
                // 可选：自动发送消息
                sendMessage();
            });
        }, 100);
    }

    // 上传到聊天会话的辅助函数
    function uploadToChatSession(file, formData) {
        $.ajax({
            url: '/api/files/upload/' + sessionId,
            type: 'POST',
            data: formData,
            processData: false,
            contentType: false,
            success: function(response) {
                console.log('文件上传成功', response);
                $('#fileInfo').text('');
                $('#fileInput').val('');
                showToast('success', '上传成功', '文件已上传，正在分析...');
            },
            error: function(error) {
                console.error('文件上传失败', error);
                hideThinkingProcess();
                $('#typingIndicator').hide();
                showMessage({
                    role: 'assistant',
                    content: '文件上传失败，请稍后再试。'
                });
                $('#fileInfo').text('');
                $('#fileInput').val('');
                showToast('error', '上传失败', '文件上传失败，请稍后重试。');
            }
        });
    }

    // ===== API 操作函数 =====

    /**
     * 导出聊天历史记录
     */
    function exportChatHistory() {
        // 格式化聊天历史
        let chatHistory = '';

        // 添加对话基本信息
        const sessionName = $('.chat-header h4 span').text();
        chatHistory += '对话名称: ' + sessionName + '\n';
        chatHistory += '导出时间: ' + formatDate(new Date(), 'yyyy-MM-dd HH:mm:ss') + '\n\n';

        $('.message-container').each(function() {
            const role = $(this).find('.message-bubble').hasClass('user') ? '用户' :
                $(this).find('.message-bubble').hasClass('system') ? '系统' : '助手';

            // 获取纯文本内容
            const content = $(this).find('.message-bubble div').html()
                .replace(/<br\s*\/?>/g, '\n')
                .replace(/<[^>]*>/g, '');

            const time = $(this).find('.message-meta').text();

            chatHistory += `[${time}] ${role}:\n${content}\n\n`;
        });

        // 创建文件并触发下载
        const blob = new Blob([chatHistory], { type: 'text/plain;charset=utf-8' });
        const url = URL.createObjectURL(blob);
        const a = document.createElement('a');
        a.href = url;
        a.download = `中德华建对话记录_${formatDate(new Date(), 'yyyyMMdd_HHmmss')}.txt`;
        document.body.appendChild(a);
        a.click();
        document.body.removeChild(a);
        URL.revokeObjectURL(url);

        showToast('success', '导出成功', '对话记录已导出为文本文件');
    }

    /**
     * 清空当前对话
     */
    function clearChat() {
        $.ajax({
            url: '/api/chat/' + sessionId + '/clear',
            type: 'POST',
            success: function() {
                // 刷新页面显示空聊天
                window.location.reload();
            },
            error: function(error) {
                console.error('清空对话失败', error);
                showToast('error', '操作失败', '清空对话失败，请稍后再试。');
            }
        });
    }

    /**
     * 重命名当前对话
     * @param {string} newName 新对话名称
     */
    function renameChat(newName) {
        $.ajax({
            url: '/api/chat/' + sessionId + '/rename',
            type: 'POST',
            data: { name: newName },
            success: function() {
                // 更新页面上的会话名称
                $('.chat-header h4 span').text(newName);
                showToast('success', '重命名成功', '对话已重命名为"' + newName + '"');
            },
            error: function(error) {
                console.error('重命名失败', error);
                showToast('error', '操作失败', '重命名对话失败，请稍后再试。');
            }
        });
    }

    /**
     * 删除指定会话
     * @param {string} sessionId 要删除的会话ID
     */
    function deleteChat(sessionId) {
        $.ajax({
            url: '/api/chat/' + sessionId,
            type: 'DELETE',
            success: function() {
                // 如果删除的是当前会话，重定向到首页
                if (sessionId === document.querySelector('meta[name="session-id"]')?.content) {
                    window.location.href = '/';
                } else {
                    // 否则只移除侧边栏中的会话项
                    $('a.session-item[href="/chat/' + sessionId + '"]').remove();
                    showToast('success', '删除成功', '对话已删除');
                }
            },
            error: function(error) {
                console.error('删除会话失败', error);
                showToast('error', '操作失败', '删除对话失败，请稍后再试。');
            }
        });
    }

    // ===== UI 辅助函数 =====

    /**
     * 显示模态框
     * @param {string} modalId 要显示的模态框ID
     */
    function showModal(modalId) {
        console.log('显示模态框:', modalId);

        // 确保所有模态框都是隐藏的
        $('.modal-backdrop').css('display', 'none');

        // 显示指定的模态框
        $('#' + modalId).css('display', 'block');

        if (modalId === 'renameModal') {
            $('#chatName').focus();
        }
    }

    /**
     * 隐藏所有模态框
     */
    function hideModals() {
        console.log('隐藏所有模态框');
        $('.modal-backdrop').css('display', 'none');
    }

    /**
     * 显示提示框
     * @param {string} type 提示类型 'success', 'warning', 'error'
     * @param {string} title 提示标题
     * @param {string} message 提示内容
     */
    function showToast(type, title, message) {
        const toastId = 'toast-' + Date.now();
        const iconClass = type === 'success' ? 'fas fa-check-circle text-success' :
            type === 'warning' ? 'fas fa-exclamation-triangle text-warning' :
                'fas fa-times-circle text-danger';

        const toast = $(`
            <div class="toast ${type}" id="${toastId}">
                <div class="toast-icon">
                    <i class="${iconClass}"></i>
                </div>
                <div class="toast-content">
                    <div class="toast-title">${title}</div>
                    <div class="toast-message">${message}</div>
                </div>
                <div class="toast-close">
                    <i class="fas fa-times"></i>
                </div>
            </div>
        `);

        $('#toastContainer').append(toast);

        // 绑定关闭事件
        toast.find('.toast-close').on('click', function() {
            toast.remove();
        });

        // 自动关闭
        setTimeout(function() {
            toast.fadeOut(300, function() {
                toast.remove();
            });
        }, 3000);
    }

    // ===== 工具函数 =====

    /**
     * 格式化文件大小
     * @param {number} bytes 字节数
     * @param {number} decimals 小数位数
     * @returns {string} 格式化后的大小字符串
     */
    function formatBytes(bytes, decimals = 2) {
        if (bytes === 0) return '0 B';

        const k = 1024;
        const dm = decimals < 0 ? 0 : decimals;
        const sizes = ['B', 'KB', 'MB', 'GB', 'TB'];

        const i = Math.floor(Math.log(bytes) / Math.log(k));

        return parseFloat((bytes / Math.pow(k, i)).toFixed(dm)) + ' ' + sizes[i];
    }

    /**
     * 格式化日期
     * @param {Date} date 日期对象
     * @param {string} format 格式化模板
     * @returns {string} 格式化后的日期字符串
     */
    function formatDate(date, format) {
        const year = date.getFullYear();
        const month = date.getMonth() + 1;
        const day = date.getDate();
        const hours = date.getHours();
        const minutes = date.getMinutes();
        const seconds = date.getSeconds();

        format = format.replace('yyyy', year);
        format = format.replace('MM', month.toString().padStart(2, '0'));
        format = format.replace('dd', day.toString().padStart(2, '0'));
        format = format.replace('HH', hours.toString().padStart(2, '0'));
        format = format.replace('mm', minutes.toString().padStart(2, '0'));
        format = format.replace('ss', seconds.toString().padStart(2, '0'));

        return format;
    }



    /**
     * 文件处理思考过程显示
     * @param {string} fileName 文件名
     */
    function showFileProcessingThinking(fileName) {
        // 根据文件类型选择不同的思考步骤
        let fileType = fileName.split('.').pop().toLowerCase();
        let thinkingSteps;

        switch(fileType) {
            case 'pdf':
                thinkingSteps = [
                    "加载PDF文档...",
                    "提取文本内容...",
                    "分析文档结构...",
                    "理解文档主题...",
                    "识别关键信息...",
                    "整理文档概要...",
                    "生成分析结果..."
                ];
                break;
            case 'csv':
            case 'xlsx':
            case 'xls':
                thinkingSteps = [
                    "加载数据文件...",
                    "识别数据结构...",
                    "分析数据类型...",
                    "处理数值数据...",
                    "统计数据特征...",
                    "寻找数据模式...",
                    "生成数据洞察..."
                ];
                break;
            case 'txt':
            case 'doc':
            case 'docx':
                thinkingSteps = [
                    "加载文本文档...",
                    "解析文本内容...",
                    "分析文本结构...",
                    "提取关键概念...",
                    "理解文档上下文...",
                    "整理文档要点...",
                    "生成文档摘要..."
                ];
                break;
            default:
                thinkingSteps = [
                    "加载文件内容...",
                    "分析文件格式...",
                    "提取文件信息...",
                    "处理文件数据...",
                    "解析文件结构...",
                    "整理文件内容...",
                    "生成分析结果..."
                ];
        }

        // 创建思考过程容器
        const thinkingContainer = $('<div id="thinking-process" class="message-container"></div>');

        // 创建AI头像
        const avatarElement = $('<div class="message-avatar"></div>')
            .append($('<i class="fas fa-robot"></i>'));

        thinkingContainer.append(avatarElement);

        // 创建思考内容
        const messageContent = $('<div class="message-content"></div>');
        const messageBubble = $('<div class="message-bubble assistant thinking-bubble"></div>')
            .append($('<div id="thinking-content"></div>').html('<p>分析文件: ' + fileName + '...</p>'));

        messageContent.append(messageBubble);
        thinkingContainer.append(messageContent);

        // 添加到消息列表
        $('#messageList').append(thinkingContainer);
        scrollToBottom();

        // 启动文件处理思考动画
        startFileProcessingAnimation(thinkingSteps);
    }

    /**
     * 启动文件处理思考动画
     * @param {Array} steps 思考步骤数组
     */
    let fileProcessingInterval;
    let processingStep = 0;

    function startFileProcessingAnimation(steps) {
        processingStep = 0;
        updateFileProcessingContent(steps);

        // 每3秒更新一次处理步骤
        fileProcessingInterval = setInterval(function() {
            processingStep++;
            if (processingStep >= steps.length) {
                processingStep = steps.length - 1; // 保持在最后一步
            }
            updateFileProcessingContent(steps);
        }, 3000);
    }

    /**
     * 更新文件处理内容
     * @param {Array} steps 思考步骤数组
     */
    function updateFileProcessingContent(steps) {
        const thinkingContent = $('#thinking-content');
        if (thinkingContent.length) {
            let content = `<p>${steps[processingStep]}</p>`;

            // 添加进度条
            content += '<div class="processing-progress">';
            content += `<div class="progress-bar" style="width: ${(processingStep + 1) / steps.length * 100}%"></div>`;
            content += '</div>';

            // 添加步骤文本
            content += `<div class="processing-step">${processingStep + 1}/${steps.length}</div>`;

            thinkingContent.html(content);
            scrollToBottom();
        }
    }

    /**
     * 隐藏思考过程
     */
    function hideThinkingProcess() {
        // 停止动画
        clearInterval(fileProcessingInterval);
        // 移除思考过程元素
        $('#thinking-process').remove();
    }


    // 全局变量，存储待发送的文件
    let pendingFiles = [];

    /**
     * 初始化文件上传事件处理
     */
    function initFileUploadEvents() {
        // 先解除可能的旧事件绑定
        $('#fileUploadButton').off('click');
        $('#fileInput').off('change');
        $('#clearPendingFiles').off('click');

        // 文件上传按钮点击事件
        $('#fileUploadButton').on('click', function() {
            $('#fileInput').click();
        });

        // 文件选择事件处理 - 修改这部分
        $('#fileInput').on('change', function() {
            const files = this.files;
            if (files && files.length > 0) {
                // 单个文件时直接上传
                if (files.length === 1) {
                    uploadFile(files[0]);
                } else {
                    // 多个文件时添加到待发送区域
                    for (let i = 0; i < files.length; i++) {
                        addPendingFile(files[i]);
                    }
                }
                // 清空文件输入，以便再次选择同一文件
                $(this).val('');
            }
        });

        // 清除所有待发送文件
        $('#clearPendingFiles').on('click', function() {
            clearPendingFiles();
        });

        // 添加发送按钮事件 - 确保它调用sendMessageWithFiles
        $('#sendButton').on('click', function() {
            // 如果有待发送文件，则调用sendMessageWithFiles
            if (pendingFiles.length > 0) {
                sendMessageWithFiles();
            } else {
                // 否则走普通消息发送流程
                sendMessage();
            }
        });
    }

    /**
     * 添加待发送文件
     * @param {File} file 文件对象
     */
    function addPendingFile(file) {
        // 添加文件到待发送列表
        pendingFiles.push(file);

        // 创建文件预览元素
        const fileItem = $(`
        <div class="pending-file-item" data-filename="${file.name}">
            <div class="file-icon">
                <i class="fas ${getFileIcon(file.name)}"></i>
            </div>
            <div class="file-details">
                <div class="file-name">${file.name}</div>
                <div class="file-size">${formatBytes(file.size)}</div>
            </div>
            <button type="button" class="btn-remove-file" data-filename="${file.name}">
                <i class="fas fa-times"></i>
            </button>
        </div>
    `);

        // 添加删除单个文件事件
        fileItem.find('.btn-remove-file').on('click', function() {
            const filename = $(this).data('filename');
            removePendingFile(filename);
        });

        // 添加到预览区域
        $('#pendingFilesList').append(fileItem);

        // 显示文件容器
        $('#pendingFilesContainer').show();

        // 更新发送按钮状态和文本
        updateSendButton();
    }

    /**
     * 移除待发送文件
     * @param {string} filename 文件名
     */
    function removePendingFile(filename) {
        // 从数组中移除
        pendingFiles = pendingFiles.filter(file => file.name !== filename);

        // 从界面中移除
        $(`.pending-file-item[data-filename="${filename}"]`).remove();

        // 如果没有文件了，隐藏容器
        if (pendingFiles.length === 0) {
            $('#pendingFilesContainer').hide();
        }

        // 更新发送按钮状态和文本
        updateSendButton();
    }

    /**
     * 清除所有待发送文件
     */
    function clearPendingFiles() {
        pendingFiles = [];
        $('#pendingFilesList').empty();
        $('#pendingFilesContainer').hide();
        updateSendButton();
    }

    /**
     * 更新发送按钮状态和文本
     */
    function updateSendButton() {
        const hasMessage = $('#messageInput').val().trim() !== '';
        const hasFiles = pendingFiles.length > 0;

        // 启用/禁用发送按钮
        $('#sendButton').prop('disabled', !hasMessage && !hasFiles);

        // 更新发送按钮文本
        if (hasFiles) {
            $('.send-with-files-text').show();
        } else {
            $('.send-with-files-text').hide();
        }
    }

    /**
     * 获取文件图标
     * @param {string} filename 文件名
     * @returns {string} 图标类名
     */
    function getFileIcon(filename) {
        const extension = filename.split('.').pop().toLowerCase();

        switch (extension) {
            case 'pdf':
                return 'fa-file-pdf';
            case 'doc':
            case 'docx':
                return 'fa-file-word';
            case 'xls':
            case 'xlsx':
                return 'fa-file-excel';
            case 'ppt':
            case 'pptx':
                return 'fa-file-powerpoint';
            case 'jpg':
            case 'jpeg':
            case 'png':
            case 'gif':
                return 'fa-file-image';
            case 'txt':
                return 'fa-file-alt';
            case 'zip':
            case 'rar':
                return 'fa-file-archive';
            default:
                return 'fa-file';
        }
    }

    /**
     * 发送消息和文件
     */
    function sendMessageWithFiles() {
        const message = $('#messageInput').val().trim();
        const hasFiles = pendingFiles.length > 0;

        if (!message && !hasFiles) return;

        // 创建显示的消息内容
        let displayContent = '';

        if (message) {
            displayContent = message;
        }

        // 添加文件信息到显示内容
        if (hasFiles) {
            if (displayContent) {
                displayContent += '\n\n';
            }

            displayContent += '📎 上传的文件：\n';
            pendingFiles.forEach(file => {
                displayContent += `- ${file.name} (${formatBytes(file.size)})\n`;
            });
        }

        // 显示用户消息
        showMessage({
            role: 'user',
            content: displayContent
        });

        // 清空输入框
        $('#messageInput').val('');
        $('#messageInput').css('height', 'auto');

        // 显示思考过程
        showThinkingProcess();

        // 显示输入指示器
        $('#typingIndicator').show();
        scrollToBottom();

        // 如果有文件，上传所有文件
        if (hasFiles) {
            uploadMultipleFiles(pendingFiles, message);
            // 清除待发送文件
            clearPendingFiles();
        } else {
            // 只发送文本消息
            sendTextMessage(message);
        }

        // 更新发送按钮状态
        updateSendButton();
    }

    /**
     * 上传多个文件
     * @param {Array} files 文件数组
     * @param {string} message 随附消息
     */
    function uploadMultipleFiles(files, message) {
        const formData = new FormData();

        // 添加消息
        if (message) {
            formData.append('message', message);
        }
        // 添加所有文件，使用相同的参数名'files'
        files.forEach(file => {
            formData.append('files', file);
        });

        // 通过AJAX上传
        $.ajax({
            url: '/api/files/upload-multiple/' + sessionId,
            type: 'POST',
            data: formData,
            processData: false,
            contentType: false,
            success: function(response) {
                console.log('文件上传成功', response);
                showToast('success', '上传成功', '文件已上传，正在分析...');
            },
            error: function(error) {
                console.error('文件上传失败', error);
                $('#typingIndicator').hide();
                hideThinkingProcess();
                showMessage({
                    role: 'assistant',
                    content: '文件上传失败，请稍后再试。'
                });
                showToast('error', '上传失败', '文件上传失败，请稍后重试。');
            }
        });
    }

    /**
     * 发送纯文本消息
     * @param {string} message 消息内容
     */
    function sendTextMessage(message) {
        $.ajax({
            url: '/api/chat/' + sessionId + '/send',
            type: 'POST',
            data: { message: message },
            success: function(response) {
                console.log('消息发送成功');
            },
            error: function(error) {
                console.error('发送消息错误', error);
                $('#typingIndicator').hide();
                hideThinkingProcess();
                showMessage({
                    role: 'assistant',
                    content: '发送消息时出错，请稍后再试。'
                });
                showToast('error', '发送失败', '无法发送消息，请检查网络连接。');
            }
        });
    }

});